home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 25 / CU Amiga Magazine's Super CD-ROM 25 (1998)(EMAP Images)(GB)(Track 1 of 2)[!][issue 1998-08].iso / CUCD / Programming / ixemul / sdk / include / sys / vnode_if.h < prev    next >
Encoding:
C/C++ Source or Header  |  1998-04-18  |  25.0 KB  |  1,041 lines
  1. /*
  2.  * Warning: This file is generated automatically.
  3.  * (Modifications made here may easily be lost!)
  4.  *
  5.  * Created from the file:
  6.  *    NetBSD: vnode_if.src,v 1.10 1996/05/11 18:26:27 mycroft Exp 
  7.  * by the script:
  8.  *    NetBSD: vnode_if.sh,v 1.9 1996/02/29 20:58:22 cgd Exp 
  9.  */
  10.  
  11. /*
  12.  * Copyright (c) 1992, 1993
  13.  *    The Regents of the University of California.  All rights reserved.
  14.  *
  15.  * Redistribution and use in source and binary forms, with or without
  16.  * modification, are permitted provided that the following conditions
  17.  * are met:
  18.  * 1. Redistributions of source code must retain the above copyright
  19.  *    notice, this list of conditions and the following disclaimer.
  20.  * 2. Redistributions in binary form must reproduce the above copyright
  21.  *    notice, this list of conditions and the following disclaimer in the
  22.  *    documentation and/or other materials provided with the distribution.
  23.  * 3. All advertising materials mentioning features or use of this software
  24.  *    must display the following acknowledgement:
  25.  *    This product includes software developed by the University of
  26.  *    California, Berkeley and its contributors.
  27.  * 4. Neither the name of the University nor the names of its contributors
  28.  *    may be used to endorse or promote products derived from this software
  29.  *    without specific prior written permission.
  30.  *
  31.  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS AS IS'' AND
  32.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  33.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  34.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  35.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  36.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  37.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  38.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  39.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  40.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  41.  * SUCH DAMAGE.
  42.  */
  43.  
  44. extern struct vnodeop_desc vop_default_desc;
  45.  
  46.  
  47. struct vop_lookup_args {
  48.     struct vnodeop_desc *a_desc;
  49.     struct vnode *a_dvp;
  50.     struct vnode **a_vpp;
  51.     struct componentname *a_cnp;
  52. };
  53. extern struct vnodeop_desc vop_lookup_desc;
  54. static __inline int VOP_LOOKUP __P((struct vnode *, struct vnode **, 
  55.     struct componentname *));
  56. static __inline int VOP_LOOKUP(dvp, vpp, cnp)
  57.     struct vnode *dvp;
  58.     struct vnode **vpp;
  59.     struct componentname *cnp;
  60. {
  61.     struct vop_lookup_args a;
  62.     a.a_desc = VDESC(vop_lookup);
  63.     a.a_dvp = dvp;
  64.     a.a_vpp = vpp;
  65.     a.a_cnp = cnp;
  66.     return (VCALL(dvp, VOFFSET(vop_lookup), &a));
  67. }
  68.  
  69. struct vop_create_args {
  70.     struct vnodeop_desc *a_desc;
  71.     struct vnode *a_dvp;
  72.     struct vnode **a_vpp;
  73.     struct componentname *a_cnp;
  74.     struct vattr *a_vap;
  75. };
  76. extern struct vnodeop_desc vop_create_desc;
  77. static __inline int VOP_CREATE __P((struct vnode *, struct vnode **, 
  78.     struct componentname *, struct vattr *));
  79. static __inline int VOP_CREATE(dvp, vpp, cnp, vap)
  80.     struct vnode *dvp;
  81.     struct vnode **vpp;
  82.     struct componentname *cnp;
  83.     struct vattr *vap;
  84. {
  85.     struct vop_create_args a;
  86.     a.a_desc = VDESC(vop_create);
  87.     a.a_dvp = dvp;
  88.     a.a_vpp = vpp;
  89.     a.a_cnp = cnp;
  90.     a.a_vap = vap;
  91.     return (VCALL(dvp, VOFFSET(vop_create), &a));
  92. }
  93.  
  94. struct vop_mknod_args {
  95.     struct vnodeop_desc *a_desc;
  96.     struct vnode *a_dvp;
  97.     struct vnode **a_vpp;
  98.     struct componentname *a_cnp;
  99.     struct vattr *a_vap;
  100. };
  101. extern struct vnodeop_desc vop_mknod_desc;
  102. static __inline int VOP_MKNOD __P((struct vnode *, struct vnode **, 
  103.     struct componentname *, struct vattr *));
  104. static __inline int VOP_MKNOD(dvp, vpp, cnp, vap)
  105.     struct vnode *dvp;
  106.     struct vnode **vpp;
  107.     struct componentname *cnp;
  108.     struct vattr *vap;
  109. {
  110.     struct vop_mknod_args a;
  111.     a.a_desc = VDESC(vop_mknod);
  112.     a.a_dvp = dvp;
  113.     a.a_vpp = vpp;
  114.     a.a_cnp = cnp;
  115.     a.a_vap = vap;
  116.     return (VCALL(dvp, VOFFSET(vop_mknod), &a));
  117. }
  118.  
  119. struct vop_open_args {
  120.     struct vnodeop_desc *a_desc;
  121.     struct vnode *a_vp;
  122.     int a_mode;
  123.     struct ucred *a_cred;
  124.     struct proc *a_p;
  125. };
  126. extern struct vnodeop_desc vop_open_desc;
  127. static __inline int VOP_OPEN __P((struct vnode *, int, struct ucred *, 
  128.     struct proc *));
  129. static __inline int VOP_OPEN(vp, mode, cred, p)
  130.     struct vnode *vp;
  131.     int mode;
  132.     struct ucred *cred;
  133.     struct proc *p;
  134. {
  135.     struct vop_open_args a;
  136.     a.a_desc = VDESC(vop_open);
  137.     a.a_vp = vp;
  138.     a.a_mode = mode;
  139.     a.a_cred = cred;
  140.     a.a_p = p;
  141.     return (VCALL(vp, VOFFSET(vop_open), &a));
  142. }
  143.  
  144. struct vop_close_args {
  145.     struct vnodeop_desc *a_desc;
  146.     struct vnode *a_vp;
  147.     int a_fflag;
  148.     struct ucred *a_cred;
  149.     struct proc *a_p;
  150. };
  151. extern struct vnodeop_desc vop_close_desc;
  152. static __inline int VOP_CLOSE __P((struct vnode *, int, struct ucred *, 
  153.     struct proc *));
  154. static __inline int VOP_CLOSE(vp, fflag, cred, p)
  155.     struct vnode *vp;
  156.     int fflag;
  157.     struct ucred *cred;
  158.     struct proc *p;
  159. {
  160.     struct vop_close_args a;
  161.     a.a_desc = VDESC(vop_close);
  162.     a.a_vp = vp;
  163.     a.a_fflag = fflag;
  164.     a.a_cred = cred;
  165.     a.a_p = p;
  166.     return (VCALL(vp, VOFFSET(vop_close), &a));
  167. }
  168.  
  169. struct vop_access_args {
  170.     struct vnodeop_desc *a_desc;
  171.     struct vnode *a_vp;
  172.     int a_mode;
  173.     struct ucred *a_cred;
  174.     struct proc *a_p;
  175. };
  176. extern struct vnodeop_desc vop_access_desc;
  177. static __inline int VOP_ACCESS __P((struct vnode *, int, struct ucred *, 
  178.     struct proc *));
  179. static __inline int VOP_ACCESS(vp, mode, cred, p)
  180.     struct vnode *vp;
  181.     int mode;
  182.     struct ucred *cred;
  183.     struct proc *p;
  184. {
  185.     struct vop_access_args a;
  186.     a.a_desc = VDESC(vop_access);
  187.     a.a_vp = vp;
  188.     a.a_mode = mode;
  189.     a.a_cred = cred;
  190.     a.a_p = p;
  191.     return (VCALL(vp, VOFFSET(vop_access), &a));
  192. }
  193.  
  194. struct vop_getattr_args {
  195.     struct vnodeop_desc *a_desc;
  196.     struct vnode *a_vp;
  197.     struct vattr *a_vap;
  198.     struct ucred *a_cred;
  199.     struct proc *a_p;
  200. };
  201. extern struct vnodeop_desc vop_getattr_desc;
  202. static __inline int VOP_GETATTR __P((struct vnode *, struct vattr *, 
  203.     struct ucred *, struct proc *));
  204. static __inline int VOP_GETATTR(vp, vap, cred, p)
  205.     struct vnode *vp;
  206.     struct vattr *vap;
  207.     struct ucred *cred;
  208.     struct proc *p;
  209. {
  210.     struct vop_getattr_args a;
  211.     a.a_desc = VDESC(vop_getattr);
  212.     a.a_vp = vp;
  213.     a.a_vap = vap;
  214.     a.a_cred = cred;
  215.     a.a_p = p;
  216.     return (VCALL(vp, VOFFSET(vop_getattr), &a));
  217. }
  218.  
  219. struct vop_setattr_args {
  220.     struct vnodeop_desc *a_desc;
  221.     struct vnode *a_vp;
  222.     struct vattr *a_vap;
  223.     struct ucred *a_cred;
  224.     struct proc *a_p;
  225. };
  226. extern struct vnodeop_desc vop_setattr_desc;
  227. static __inline int VOP_SETATTR __P((struct vnode *, struct vattr *, 
  228.     struct ucred *, struct proc *));
  229. static __inline int VOP_SETATTR(vp, vap, cred, p)
  230.     struct vnode *vp;
  231.     struct vattr *vap;
  232.     struct ucred *cred;
  233.     struct proc *p;
  234. {
  235.     struct vop_setattr_args a;
  236.     a.a_desc = VDESC(vop_setattr);
  237.     a.a_vp = vp;
  238.     a.a_vap = vap;
  239.     a.a_cred = cred;
  240.     a.a_p = p;
  241.     return (VCALL(vp, VOFFSET(vop_setattr), &a));
  242. }
  243.  
  244. struct vop_read_args {
  245.     struct vnodeop_desc *a_desc;
  246.     struct vnode *a_vp;
  247.     struct uio *a_uio;
  248.     int a_ioflag;
  249.     struct ucred *a_cred;
  250. };
  251. extern struct vnodeop_desc vop_read_desc;
  252. static __inline int VOP_READ __P((struct vnode *, struct uio *, int, 
  253.     struct ucred *));
  254. static __inline int VOP_READ(vp, uio, ioflag, cred)
  255.     struct vnode *vp;
  256.     struct uio *uio;
  257.     int ioflag;
  258.     struct ucred *cred;
  259. {
  260.     struct vop_read_args a;
  261.     a.a_desc = VDESC(vop_read);
  262.     a.a_vp = vp;
  263.     a.a_uio = uio;
  264.     a.a_ioflag = ioflag;
  265.     a.a_cred = cred;
  266.     return (VCALL(vp, VOFFSET(vop_read), &a));
  267. }
  268.  
  269. struct vop_write_args {
  270.     struct vnodeop_desc *a_desc;
  271.     struct vnode *a_vp;
  272.     struct uio *a_uio;
  273.     int a_ioflag;
  274.     struct ucred *a_cred;
  275. };
  276. extern struct vnodeop_desc vop_write_desc;
  277. static __inline int VOP_WRITE __P((struct vnode *, struct uio *, int, 
  278.     struct ucred *));
  279. static __inline int VOP_WRITE(vp, uio, ioflag, cred)
  280.     struct vnode *vp;
  281.     struct uio *uio;
  282.     int ioflag;
  283.     struct ucred *cred;
  284. {
  285.     struct vop_write_args a;
  286.     a.a_desc = VDESC(vop_write);
  287.     a.a_vp = vp;
  288.     a.a_uio = uio;
  289.     a.a_ioflag = ioflag;
  290.     a.a_cred = cred;
  291.     return (VCALL(vp, VOFFSET(vop_write), &a));
  292. }
  293.  
  294. struct vop_ioctl_args {
  295.     struct vnodeop_desc *a_desc;
  296.     struct vnode *a_vp;
  297.     u_long a_command;
  298.     caddr_t a_data;
  299.     int a_fflag;
  300.     struct ucred *a_cred;
  301.     struct proc *a_p;
  302. };
  303. extern struct vnodeop_desc vop_ioctl_desc;
  304. static __inline int VOP_IOCTL __P((struct vnode *, u_long, caddr_t, int, 
  305.     struct ucred *, struct proc *));
  306. static __inline int VOP_IOCTL(vp, command, data, fflag, cred, p)
  307.     struct vnode *vp;
  308.     u_long command;
  309.     caddr_t data;
  310.     int fflag;
  311.     struct ucred *cred;
  312.     struct proc *p;
  313. {
  314.     struct vop_ioctl_args a;
  315.     a.a_desc = VDESC(vop_ioctl);
  316.     a.a_vp = vp;
  317.     a.a_command = command;
  318.     a.a_data = data;
  319.     a.a_fflag = fflag;
  320.     a.a_cred = cred;
  321.     a.a_p = p;
  322.     return (VCALL(vp, VOFFSET(vop_ioctl), &a));
  323. }
  324.  
  325. struct vop_select_args {
  326.     struct vnodeop_desc *a_desc;
  327.     struct vnode *a_vp;
  328.     int a_which;
  329.     int a_fflags;
  330.     struct ucred *a_cred;
  331.     struct proc *a_p;
  332. };
  333. extern struct vnodeop_desc vop_select_desc;
  334. static __inline int VOP_SELECT __P((struct vnode *, int, int, 
  335.     struct ucred *, struct proc *));
  336. static __inline int VOP_SELECT(vp, which, fflags, cred, p)
  337.     struct vnode *vp;
  338.     int which;
  339.     int fflags;
  340.     struct ucred *cred;
  341.     struct proc *p;
  342. {
  343.     struct vop_select_args a;
  344.     a.a_desc = VDESC(vop_select);
  345.     a.a_vp = vp;
  346.     a.a_which = which;
  347.     a.a_fflags = fflags;
  348.     a.a_cred = cred;
  349.     a.a_p = p;
  350.     return (VCALL(vp, VOFFSET(vop_select), &a));
  351. }
  352.  
  353. struct vop_mmap_args {
  354.     struct vnodeop_desc *a_desc;
  355.     struct vnode *a_vp;
  356.     int a_fflags;
  357.     struct ucred *a_cred;
  358.     struct proc *a_p;
  359. };
  360. extern struct vnodeop_desc vop_mmap_desc;
  361. static __inline int VOP_MMAP __P((struct vnode *, int, struct ucred *, 
  362.     struct proc *));
  363. static __inline int VOP_MMAP(vp, fflags, cred, p)
  364.     struct vnode *vp;
  365.     int fflags;
  366.     struct ucred *cred;
  367.     struct proc *p;
  368. {
  369.     struct vop_mmap_args a;
  370.     a.a_desc = VDESC(vop_mmap);
  371.     a.a_vp = vp;
  372.     a.a_fflags = fflags;
  373.     a.a_cred = cred;
  374.     a.a_p = p;
  375.     return (VCALL(vp, VOFFSET(vop_mmap), &a));
  376. }
  377.  
  378. struct vop_fsync_args {
  379.     struct vnodeop_desc *a_desc;
  380.     struct vnode *a_vp;
  381.     struct ucred *a_cred;
  382.     int a_waitfor;
  383.     struct proc *a_p;
  384. };
  385. extern struct vnodeop_desc vop_fsync_desc;
  386. static __inline int VOP_FSYNC __P((struct vnode *, struct ucred *, int, 
  387.     struct proc *));
  388. static __inline int VOP_FSYNC(vp, cred, waitfor, p)
  389.     struct vnode *vp;
  390.     struct ucred *cred;
  391.     int waitfor;
  392.     struct proc *p;
  393. {
  394.     struct vop_fsync_args a;
  395.     a.a_desc = VDESC(vop_fsync);
  396.     a.a_vp = vp;
  397.     a.a_cred = cred;
  398.     a.a_waitfor = waitfor;
  399.     a.a_p = p;
  400.     return (VCALL(vp, VOFFSET(vop_fsync), &a));
  401. }
  402.  
  403. struct vop_seek_args {
  404.     struct vnodeop_desc *a_desc;
  405.     struct vnode *a_vp;
  406.     off_t a_oldoff;
  407.     off_t a_newoff;
  408.     struct ucred *a_cred;
  409. };
  410. extern struct vnodeop_desc vop_seek_desc;
  411. static __inline int VOP_SEEK __P((struct vnode *, off_t, off_t, 
  412.     struct ucred *));
  413. static __inline int VOP_SEEK(vp, oldoff, newoff, cred)
  414.     struct vnode *vp;
  415.     off_t oldoff;
  416.     off_t newoff;
  417.     struct ucred *cred;
  418. {
  419.     struct vop_seek_args a;
  420.     a.a_desc = VDESC(vop_seek);
  421.     a.a_vp = vp;
  422.     a.a_oldoff = oldoff;
  423.     a.a_newoff = newoff;
  424.     a.a_cred = cred;
  425.     return (VCALL(vp, VOFFSET(vop_seek), &a));
  426. }
  427.  
  428. struct vop_remove_args {
  429.     struct vnodeop_desc *a_desc;
  430.     struct vnode *a_dvp;
  431.     struct vnode *a_vp;
  432.     struct componentname *a_cnp;
  433. };
  434. extern struct vnodeop_desc vop_remove_desc;
  435. static __inline int VOP_REMOVE __P((struct vnode *, struct vnode *, 
  436.     struct componentname *));
  437. static __inline int VOP_REMOVE(dvp, vp, cnp)
  438.     struct vnode *dvp;
  439.     struct vnode *vp;
  440.     struct componentname *cnp;
  441. {
  442.     struct vop_remove_args a;
  443.     a.a_desc = VDESC(vop_remove);
  444.     a.a_dvp = dvp;
  445.     a.a_vp = vp;
  446.     a.a_cnp = cnp;
  447.     return (VCALL(dvp, VOFFSET(vop_remove), &a));
  448. }
  449.  
  450. struct vop_link_args {
  451.     struct vnodeop_desc *a_desc;
  452.     struct vnode *a_dvp;
  453.     struct vnode *a_vp;
  454.     struct componentname *a_cnp;
  455. };
  456. extern struct vnodeop_desc vop_link_desc;
  457. static __inline int VOP_LINK __P((struct vnode *, struct vnode *, 
  458.     struct componentname *));
  459. static __inline int VOP_LINK(dvp, vp, cnp)
  460.     struct vnode *dvp;
  461.     struct vnode *vp;
  462.     struct componentname *cnp;
  463. {
  464.     struct vop_link_args a;
  465.     a.a_desc = VDESC(vop_link);
  466.     a.a_dvp = dvp;
  467.     a.a_vp = vp;
  468.     a.a_cnp = cnp;
  469.     return (VCALL(dvp, VOFFSET(vop_link), &a));
  470. }
  471.  
  472. struct vop_rename_args {
  473.     struct vnodeop_desc *a_desc;
  474.     struct vnode *a_fdvp;
  475.     struct vnode *a_fvp;
  476.     struct componentname *a_fcnp;
  477.     struct vnode *a_tdvp;
  478.     struct vnode *a_tvp;
  479.     struct componentname *a_tcnp;
  480. };
  481. extern struct vnodeop_desc vop_rename_desc;
  482. static __inline int VOP_RENAME __P((struct vnode *, struct vnode *, 
  483.     struct componentname *, struct vnode *, struct vnode *, 
  484.     struct componentname *));
  485. static __inline int VOP_RENAME(fdvp, fvp, fcnp, tdvp, tvp, tcnp)
  486.     struct vnode *fdvp;
  487.     struct vnode *fvp;
  488.     struct componentname *fcnp;
  489.     struct vnode *tdvp;
  490.     struct vnode *tvp;
  491.     struct componentname *tcnp;
  492. {
  493.     struct vop_rename_args a;
  494.     a.a_desc = VDESC(vop_rename);
  495.     a.a_fdvp = fdvp;
  496.     a.a_fvp = fvp;
  497.     a.a_fcnp = fcnp;
  498.     a.a_tdvp = tdvp;
  499.     a.a_tvp = tvp;
  500.     a.a_tcnp = tcnp;
  501.     return (VCALL(fdvp, VOFFSET(vop_rename), &a));
  502. }
  503.  
  504. struct vop_mkdir_args {
  505.     struct vnodeop_desc *a_desc;
  506.     struct vnode *a_dvp;
  507.     struct vnode **a_vpp;
  508.     struct componentname *a_cnp;
  509.     struct vattr *a_vap;
  510. };
  511. extern struct vnodeop_desc vop_mkdir_desc;
  512. static __inline int VOP_MKDIR __P((struct vnode *, struct vnode **, 
  513.     struct componentname *, struct vattr *));
  514. static __inline int VOP_MKDIR(dvp, vpp, cnp, vap)
  515.     struct vnode *dvp;
  516.     struct vnode **vpp;
  517.     struct componentname *cnp;
  518.     struct vattr *vap;
  519. {
  520.     struct vop_mkdir_args a;
  521.     a.a_desc = VDESC(vop_mkdir);
  522.     a.a_dvp = dvp;
  523.     a.a_vpp = vpp;
  524.     a.a_cnp = cnp;
  525.     a.a_vap = vap;
  526.     return (VCALL(dvp, VOFFSET(vop_mkdir), &a));
  527. }
  528.  
  529. struct vop_rmdir_args {
  530.     struct vnodeop_desc *a_desc;
  531.     struct vnode *a_dvp;
  532.     struct vnode *a_vp;
  533.     struct componentname *a_cnp;
  534. };
  535. extern struct vnodeop_desc vop_rmdir_desc;
  536. static __inline int VOP_RMDIR __P((struct vnode *, struct vnode *, 
  537.     struct componentname *));
  538. static __inline int VOP_RMDIR(dvp, vp, cnp)
  539.     struct vnode *dvp;
  540.     struct vnode *vp;
  541.     struct componentname *cnp;
  542. {
  543.     struct vop_rmdir_args a;
  544.     a.a_desc = VDESC(vop_rmdir);
  545.     a.a_dvp = dvp;
  546.     a.a_vp = vp;
  547.     a.a_cnp = cnp;
  548.     return (VCALL(dvp, VOFFSET(vop_rmdir), &a));
  549. }
  550.  
  551. struct vop_symlink_args {
  552.     struct vnodeop_desc *a_desc;
  553.     struct vnode *a_dvp;
  554.     struct vnode **a_vpp;
  555.     struct componentname *a_cnp;
  556.     struct vattr *a_vap;
  557.     char *a_target;
  558. };
  559. extern struct vnodeop_desc vop_symlink_desc;
  560. static __inline int VOP_SYMLINK __P((struct vnode *, struct vnode **, 
  561.     struct componentname *, struct vattr *, char *));
  562. static __inline int VOP_SYMLINK(dvp, vpp, cnp, vap, target)
  563.     struct vnode *dvp;
  564.     struct vnode **vpp;
  565.     struct componentname *cnp;
  566.     struct vattr *vap;
  567.     char *target;
  568. {
  569.     struct vop_symlink_args a;
  570.     a.a_desc = VDESC(vop_symlink);
  571.     a.a_dvp = dvp;
  572.     a.a_vpp = vpp;
  573.     a.a_cnp = cnp;
  574.     a.a_vap = vap;
  575.     a.a_target = target;
  576.     return (VCALL(dvp, VOFFSET(vop_symlink), &a));
  577. }
  578.  
  579. struct vop_readdir_args {
  580.     struct vnodeop_desc *a_desc;
  581.     struct vnode *a_vp;
  582.     struct uio *a_uio;
  583.     struct ucred *a_cred;
  584.     int *a_eofflag;
  585.     u_long *a_cookies;
  586.     int a_ncookies;
  587. };
  588. extern struct vnodeop_desc vop_readdir_desc;
  589. static __inline int VOP_READDIR __P((struct vnode *, struct uio *, 
  590.     struct ucred *, int *, u_long *, int));
  591. static __inline int VOP_READDIR(vp, uio, cred, eofflag, cookies, ncookies)
  592.     struct vnode *vp;
  593.     struct uio *uio;
  594.     struct ucred *cred;
  595.     int *eofflag;
  596.     u_long *cookies;
  597.     int ncookies;
  598. {
  599.     struct vop_readdir_args a;
  600.     a.a_desc = VDESC(vop_readdir);
  601.     a.a_vp = vp;
  602.     a.a_uio = uio;
  603.     a.a_cred = cred;
  604.     a.a_eofflag = eofflag;
  605.     a.a_cookies = cookies;
  606.     a.a_ncookies = ncookies;
  607.     return (VCALL(vp, VOFFSET(vop_readdir), &a));
  608. }
  609.  
  610. struct vop_readlink_args {
  611.     struct vnodeop_desc *a_desc;
  612.     struct vnode *a_vp;
  613.     struct uio *a_uio;
  614.     struct ucred *a_cred;
  615. };
  616. extern struct vnodeop_desc vop_readlink_desc;
  617. static __inline int VOP_READLINK __P((struct vnode *, struct uio *, 
  618.     struct ucred *));
  619. static __inline int VOP_READLINK(vp, uio, cred)
  620.     struct vnode *vp;
  621.     struct uio *uio;
  622.     struct ucred *cred;
  623. {
  624.     struct vop_readlink_args a;
  625.     a.a_desc = VDESC(vop_readlink);
  626.     a.a_vp = vp;
  627.     a.a_uio = uio;
  628.     a.a_cred = cred;
  629.     return (VCALL(vp, VOFFSET(vop_readlink), &a));
  630. }
  631.  
  632. struct vop_abortop_args {
  633.     struct vnodeop_desc *a_desc;
  634.     struct vnode *a_dvp;
  635.     struct componentname *a_cnp;
  636. };
  637. extern struct vnodeop_desc vop_abortop_desc;
  638. static __inline int VOP_ABORTOP __P((struct vnode *, struct componentname *));
  639. static __inline int VOP_ABORTOP(dvp, cnp)
  640.     struct vnode *dvp;
  641.     struct componentname *cnp;
  642. {
  643.     struct vop_abortop_args a;
  644.     a.a_desc = VDESC(vop_abortop);
  645.     a.a_dvp = dvp;
  646.     a.a_cnp = cnp;
  647.     return (VCALL(dvp, VOFFSET(vop_abortop), &a));
  648. }
  649.  
  650. struct vop_inactive_args {
  651.     struct vnodeop_desc *a_desc;
  652.     struct vnode *a_vp;
  653. };
  654. extern struct vnodeop_desc vop_inactive_desc;
  655. static __inline int VOP_INACTIVE __P((struct vnode *));
  656. static __inline int VOP_INACTIVE(vp)
  657.     struct vnode *vp;
  658. {
  659.     struct vop_inactive_args a;
  660.     a.a_desc = VDESC(vop_inactive);
  661.     a.a_vp = vp;
  662.     return (VCALL(vp, VOFFSET(vop_inactive), &a));
  663. }
  664.  
  665. struct vop_reclaim_args {
  666.     struct vnodeop_desc *a_desc;
  667.     struct vnode *a_vp;
  668. };
  669. extern struct vnodeop_desc vop_reclaim_desc;
  670. static __inline int VOP_RECLAIM __P((struct vnode *));
  671. static __inline int VOP_RECLAIM(vp)
  672.     struct vnode *vp;
  673. {
  674.     struct vop_reclaim_args a;
  675.     a.a_desc = VDESC(vop_reclaim);
  676.     a.a_vp = vp;
  677.     return (VCALL(vp, VOFFSET(vop_reclaim), &a));
  678. }
  679.  
  680. struct vop_lock_args {
  681.     struct vnodeop_desc *a_desc;
  682.     struct vnode *a_vp;
  683. };
  684. extern struct vnodeop_desc vop_lock_desc;
  685. static __inline int VOP_LOCK __P((struct vnode *));
  686. static __inline int VOP_LOCK(vp)
  687.     struct vnode *vp;
  688. {
  689.     struct vop_lock_args a;
  690.     a.a_desc = VDESC(vop_lock);
  691.     a.a_vp = vp;
  692.     return (VCALL(vp, VOFFSET(vop_lock), &a));
  693. }
  694.  
  695. struct vop_unlock_args {
  696.     struct vnodeop_desc *a_desc;
  697.     struct vnode *a_vp;
  698. };
  699. extern struct vnodeop_desc vop_unlock_desc;
  700. static __inline int VOP_UNLOCK __P((struct vnode *));
  701. static __inline int VOP_UNLOCK(vp)
  702.     struct vnode *vp;
  703. {
  704.     struct vop_unlock_args a;
  705.     a.a_desc = VDESC(vop_unlock);
  706.     a.a_vp = vp;
  707.     return (VCALL(vp, VOFFSET(vop_unlock), &a));
  708. }
  709.  
  710. struct vop_bmap_args {
  711.     struct vnodeop_desc *a_desc;
  712.     struct vnode *a_vp;
  713.     daddr_t a_bn;
  714.     struct vnode **a_vpp;
  715.     daddr_t *a_bnp;
  716.     int *a_runp;
  717. };
  718. extern struct vnodeop_desc vop_bmap_desc;
  719. static __inline int VOP_BMAP __P((struct vnode *, daddr_t, struct vnode **, 
  720.     daddr_t *, int *));
  721. static __inline int VOP_BMAP(vp, bn, vpp, bnp, runp)
  722.     struct vnode *vp;
  723.     daddr_t bn;
  724.     struct vnode **vpp;
  725.     daddr_t *bnp;
  726.     int *runp;
  727. {
  728.     struct vop_bmap_args a;
  729.     a.a_desc = VDESC(vop_bmap);
  730.     a.a_vp = vp;
  731.     a.a_bn = bn;
  732.     a.a_vpp = vpp;
  733.     a.a_bnp = bnp;
  734.     a.a_runp = runp;
  735.     return (VCALL(vp, VOFFSET(vop_bmap), &a));
  736. }
  737.  
  738. struct vop_print_args {
  739.     struct vnodeop_desc *a_desc;
  740.     struct vnode *a_vp;
  741. };
  742. extern struct vnodeop_desc vop_print_desc;
  743. static __inline int VOP_PRINT __P((struct vnode *));
  744. static __inline int VOP_PRINT(vp)
  745.     struct vnode *vp;
  746. {
  747.     struct vop_print_args a;
  748.     a.a_desc = VDESC(vop_print);
  749.     a.a_vp = vp;
  750.     return (VCALL(vp, VOFFSET(vop_print), &a));
  751. }
  752.  
  753. struct vop_islocked_args {
  754.     struct vnodeop_desc *a_desc;
  755.     struct vnode *a_vp;
  756. };
  757. extern struct vnodeop_desc vop_islocked_desc;
  758. static __inline int VOP_ISLOCKED __P((struct vnode *));
  759. static __inline int VOP_ISLOCKED(vp)
  760.     struct vnode *vp;
  761. {
  762.     struct vop_islocked_args a;
  763.     a.a_desc = VDESC(vop_islocked);
  764.     a.a_vp = vp;
  765.     return (VCALL(vp, VOFFSET(vop_islocked), &a));
  766. }
  767.  
  768. struct vop_pathconf_args {
  769.     struct vnodeop_desc *a_desc;
  770.     struct vnode *a_vp;
  771.     int a_name;
  772.     register_t *a_retval;
  773. };
  774. extern struct vnodeop_desc vop_pathconf_desc;
  775. static __inline int VOP_PATHCONF __P((struct vnode *, int, register_t *));
  776. static __inline int VOP_PATHCONF(vp, name, retval)
  777.     struct vnode *vp;
  778.     int name;
  779.     register_t *retval;
  780. {
  781.     struct vop_pathconf_args a;
  782.     a.a_desc = VDESC(vop_pathconf);
  783.     a.a_vp = vp;
  784.     a.a_name = name;
  785.     a.a_retval = retval;
  786.     return (VCALL(vp, VOFFSET(vop_pathconf), &a));
  787. }
  788.  
  789. struct vop_advlock_args {
  790.     struct vnodeop_desc *a_desc;
  791.     struct vnode *a_vp;
  792.     caddr_t a_id;
  793.     int a_op;
  794.     struct flock *a_fl;
  795.     int a_flags;
  796. };
  797. extern struct vnodeop_desc vop_advlock_desc;
  798. static __inline int VOP_ADVLOCK __P((struct vnode *, caddr_t, int, 
  799.     struct flock *, int));
  800. static __inline int VOP_ADVLOCK(vp, id, op, fl, flags)
  801.     struct vnode *vp;
  802.     caddr_t id;
  803.     int op;
  804.     struct flock *fl;
  805.     int flags;
  806. {
  807.     struct vop_advlock_args a;
  808.     a.a_desc = VDESC(vop_advlock);
  809.     a.a_vp = vp;
  810.     a.a_id = id;
  811.     a.a_op = op;
  812.     a.a_fl = fl;
  813.     a.a_flags = flags;
  814.     return (VCALL(vp, VOFFSET(vop_advlock), &a));
  815. }
  816.  
  817. struct vop_blkatoff_args {
  818.     struct vnodeop_desc *a_desc;
  819.     struct vnode *a_vp;
  820.     off_t a_offset;
  821.     char **a_res;
  822.     struct buf **a_bpp;
  823. };
  824. extern struct vnodeop_desc vop_blkatoff_desc;
  825. static __inline int VOP_BLKATOFF __P((struct vnode *, off_t, char **, 
  826.     struct buf **));
  827. static __inline int VOP_BLKATOFF(vp, offset, res, bpp)
  828.     struct vnode *vp;
  829.     off_t offset;
  830.     char **res;
  831.     struct buf **bpp;
  832. {
  833.     struct vop_blkatoff_args a;
  834.     a.a_desc = VDESC(vop_blkatoff);
  835.     a.a_vp = vp;
  836.     a.a_offset = offset;
  837.     a.a_res = res;
  838.     a.a_bpp = bpp;
  839.     return (VCALL(vp, VOFFSET(vop_blkatoff), &a));
  840. }
  841.  
  842. struct vop_valloc_args {
  843.     struct vnodeop_desc *a_desc;
  844.     struct vnode *a_pvp;
  845.     int a_mode;
  846.     struct ucred *a_cred;
  847.     struct vnode **a_vpp;
  848. };
  849. extern struct vnodeop_desc vop_valloc_desc;
  850. static __inline int VOP_VALLOC __P((struct vnode *, int, struct ucred *, 
  851.     struct vnode **));
  852. static __inline int VOP_VALLOC(pvp, mode, cred, vpp)
  853.     struct vnode *pvp;
  854.     int mode;
  855.     struct ucred *cred;
  856.     struct vnode **vpp;
  857. {
  858.     struct vop_valloc_args a;
  859.     a.a_desc = VDESC(vop_valloc);
  860.     a.a_pvp = pvp;
  861.     a.a_mode = mode;
  862.     a.a_cred = cred;
  863.     a.a_vpp = vpp;
  864.     return (VCALL(pvp, VOFFSET(vop_valloc), &a));
  865. }
  866.  
  867. struct vop_reallocblks_args {
  868.     struct vnodeop_desc *a_desc;
  869.     struct vnode *a_vp;
  870.     struct cluster_save *a_buflist;
  871. };
  872. extern struct vnodeop_desc vop_reallocblks_desc;
  873. static __inline int VOP_REALLOCBLKS __P((struct vnode *, 
  874.     struct cluster_save *));
  875. static __inline int VOP_REALLOCBLKS(vp, buflist)
  876.     struct vnode *vp;
  877.     struct cluster_save *buflist;
  878. {
  879.     struct vop_reallocblks_args a;
  880.     a.a_desc = VDESC(vop_reallocblks);
  881.     a.a_vp = vp;
  882.     a.a_buflist = buflist;
  883.     return (VCALL(vp, VOFFSET(vop_reallocblks), &a));
  884. }
  885.  
  886. struct vop_vfree_args {
  887.     struct vnodeop_desc *a_desc;
  888.     struct vnode *a_pvp;
  889.     ino_t a_ino;
  890.     int a_mode;
  891. };
  892. extern struct vnodeop_desc vop_vfree_desc;
  893. static __inline int VOP_VFREE __P((struct vnode *, ino_t, int));
  894. static __inline int VOP_VFREE(pvp, ino, mode)
  895.     struct vnode *pvp;
  896.     ino_t ino;
  897.     int mode;
  898. {
  899.     struct vop_vfree_args a;
  900.     a.a_desc = VDESC(vop_vfree);
  901.     a.a_pvp = pvp;
  902.     a.a_ino = ino;
  903.     a.a_mode = mode;
  904.     return (VCALL(pvp, VOFFSET(vop_vfree), &a));
  905. }
  906.  
  907. struct vop_truncate_args {
  908.     struct vnodeop_desc *a_desc;
  909.     struct vnode *a_vp;
  910.     off_t a_length;
  911.     int a_flags;
  912.     struct ucred *a_cred;
  913.     struct proc *a_p;
  914. };
  915. extern struct vnodeop_desc vop_truncate_desc;
  916. static __inline int VOP_TRUNCATE __P((struct vnode *, off_t, int, 
  917.     struct ucred *, struct proc *));
  918. static __inline int VOP_TRUNCATE(vp, length, flags, cred, p)
  919.     struct vnode *vp;
  920.     off_t length;
  921.     int flags;
  922.     struct ucred *cred;
  923.     struct proc *p;
  924. {
  925.     struct vop_truncate_args a;
  926.     a.a_desc = VDESC(vop_truncate);
  927.     a.a_vp = vp;
  928.     a.a_length = length;
  929.     a.a_flags = flags;
  930.     a.a_cred = cred;
  931.     a.a_p = p;
  932.     return (VCALL(vp, VOFFSET(vop_truncate), &a));
  933. }
  934.  
  935. struct vop_update_args {
  936.     struct vnodeop_desc *a_desc;
  937.     struct vnode *a_vp;
  938.     struct timespec *a_access;
  939.     struct timespec *a_modify;
  940.     int a_waitfor;
  941. };
  942. extern struct vnodeop_desc vop_update_desc;
  943. static __inline int VOP_UPDATE __P((struct vnode *, struct timespec *, 
  944.     struct timespec *, int));
  945. static __inline int VOP_UPDATE(vp, access, modify, waitfor)
  946.     struct vnode *vp;
  947.     struct timespec *access;
  948.     struct timespec *modify;
  949.     int waitfor;
  950. {
  951.     struct vop_update_args a;
  952.     a.a_desc = VDESC(vop_update);
  953.     a.a_vp = vp;
  954.     a.a_access = access;
  955.     a.a_modify = modify;
  956.     a.a_waitfor = waitfor;
  957.     return (VCALL(vp, VOFFSET(vop_update), &a));
  958. }
  959.  
  960. struct vop_lease_args {
  961.     struct vnodeop_desc *a_desc;
  962.     struct vnode *a_vp;
  963.     struct proc *a_p;
  964.     struct ucred *a_cred;
  965.     int a_flag;
  966. };
  967. extern struct vnodeop_desc vop_lease_desc;
  968. static __inline int VOP_LEASE __P((struct vnode *, struct proc *, 
  969.     struct ucred *, int));
  970. static __inline int VOP_LEASE(vp, p, cred, flag)
  971.     struct vnode *vp;
  972.     struct proc *p;
  973.     struct ucred *cred;
  974.     int flag;
  975. {
  976.     struct vop_lease_args a;
  977.     a.a_desc = VDESC(vop_lease);
  978.     a.a_vp = vp;
  979.     a.a_p = p;
  980.     a.a_cred = cred;
  981.     a.a_flag = flag;
  982.     return (VCALL(vp, VOFFSET(vop_lease), &a));
  983. }
  984.  
  985. struct vop_whiteout_args {
  986.     struct vnodeop_desc *a_desc;
  987.     struct vnode *a_dvp;
  988.     struct componentname *a_cnp;
  989.     int a_flags;
  990. };
  991. extern struct vnodeop_desc vop_whiteout_desc;
  992. static __inline int VOP_WHITEOUT __P((struct vnode *, 
  993.     struct componentname *, int));
  994. static __inline int VOP_WHITEOUT(dvp, cnp, flags)
  995.     struct vnode *dvp;
  996.     struct componentname *cnp;
  997.     int flags;
  998. {
  999.     struct vop_whiteout_args a;
  1000.     a.a_desc = VDESC(vop_whiteout);
  1001.     a.a_dvp = dvp;
  1002.     a.a_cnp = cnp;
  1003.     a.a_flags = flags;
  1004.     return (VCALL(dvp, VOFFSET(vop_whiteout), &a));
  1005. }
  1006.  
  1007. /* Special cases: */
  1008. #include <sys/buf.h>
  1009.  
  1010. struct vop_strategy_args {
  1011.     struct vnodeop_desc *a_desc;
  1012.     struct buf *a_bp;
  1013. };
  1014. extern struct vnodeop_desc vop_strategy_desc;
  1015. static __inline int VOP_STRATEGY __P((struct buf *));
  1016. static __inline int VOP_STRATEGY(bp)
  1017.     struct buf *bp;
  1018. {
  1019.     struct vop_strategy_args a;
  1020.     a.a_desc = VDESC(vop_strategy);
  1021.     a.a_bp = bp;
  1022.     return (VCALL(bp->b_vp, VOFFSET(vop_strategy), &a));
  1023. }
  1024.  
  1025. struct vop_bwrite_args {
  1026.     struct vnodeop_desc *a_desc;
  1027.     struct buf *a_bp;
  1028. };
  1029. extern struct vnodeop_desc vop_bwrite_desc;
  1030. static __inline int VOP_BWRITE __P((struct buf *));
  1031. static __inline int VOP_BWRITE(bp)
  1032.     struct buf *bp;
  1033. {
  1034.     struct vop_bwrite_args a;
  1035.     a.a_desc = VDESC(vop_bwrite);
  1036.     a.a_bp = bp;
  1037.     return (VCALL(bp->b_vp, VOFFSET(vop_bwrite), &a));
  1038. }
  1039.  
  1040. /* End of special cases. */
  1041.